/*
 * Copyright (c) 1995, 2013, Oracle and/or its affiliates. All rights reserved.
 * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 */

package java.awt;

import java.beans.PropertyChangeEvent;
import java.awt.event.*;
import java.awt.peer.*;
import java.awt.im.InputMethodHighlight;
import java.awt.image.ImageObserver;
import java.awt.image.ImageProducer;
import java.awt.image.ColorModel;
import java.awt.datatransfer.Clipboard;
import java.awt.dnd.DragSource;
import java.awt.dnd.DragGestureRecognizer;
import java.awt.dnd.DragGestureEvent;
import java.awt.dnd.DragGestureListener;
import java.awt.dnd.InvalidDnDOperationException;
import java.awt.dnd.peer.DragSourceContextPeer;
import java.net.URL;
import java.io.File;
import java.io.FileInputStream;

import java.util.*;
import java.beans.PropertyChangeListener;
import java.beans.PropertyChangeSupport;
import sun.awt.AppContext;

import sun.awt.HeadlessToolkit;
import sun.awt.NullComponentPeer;
import sun.awt.PeerEvent;
import sun.awt.SunToolkit;
import sun.awt.AWTAccessor;
import sun.security.util.SecurityConstants;

import sun.util.CoreResourceBundleControl;

/**
 * This class is the abstract superclass of all actual
 * implementations of the Abstract Window Toolkit. Subclasses of
 * the <code>Toolkit</code> class are used to bind the various components
 * to particular native toolkit implementations.
 * <p>
 * Many GUI events may be delivered to user
 * asynchronously, if the opposite is not specified explicitly.
 * As well as
 * many GUI operations may be performed asynchronously.
 * This fact means that if the state of a component is set, and then
 * the state immediately queried, the returned value may not yet
 * reflect the requested change.  This behavior includes, but is not
 * limited to:
 * <ul>
 * <li>Scrolling to a specified position.
 * <br>For example, calling <code>ScrollPane.setScrollPosition</code>
 * and then <code>getScrollPosition</code> may return an incorrect
 * value if the original request has not yet been processed.
 *
 * <li>Moving the focus from one component to another.
 * <br>For more information, see
 * <a href="https://docs.oracle.com/javase/tutorial/uiswing/misc/focus.html#transferTiming">Timing
 * Focus Transfers</a>, a section in
 * <a href="http://java.sun.com/docs/books/tutorial/uiswing/">The Swing
 * Tutorial</a>.
 *
 * <li>Making a top-level container visible.
 * <br>Calling <code>setVisible(true)</code> on a <code>Window</code>,
 * <code>Frame</code> or <code>Dialog</code> may occur
 * asynchronously.
 *
 * <li>Setting the size or location of a top-level container.
 * <br>Calls to <code>setSize</code>, <code>setBounds</code> or
 * <code>setLocation</code> on a <code>Window</code>,
 * <code>Frame</code> or <code>Dialog</code> are forwarded
 * to the underlying window management system and may be
 * ignored or modified.  See {@link java.awt.Window} for
 * more information.
 * </ul>
 * <p>
 * Most applications should not call any of the methods in this
 * class directly. The methods defined by <code>Toolkit</code> are
 * the "glue" that joins the platform-independent classes in the
 * <code>java.awt</code> package with their counterparts in
 * <code>java.awt.peer</code>. Some methods defined by
 * <code>Toolkit</code> query the native operating system directly.
 *
 * @author Sami Shaio
 * @author Arthur van Hoff
 * @author Fred Ecks
 * @since JDK1.0
 */
public abstract class Toolkit {

  /**
   * Creates this toolkit's implementation of the <code>Desktop</code>
   * using the specified peer interface.
   *
   * @param target the desktop to be implemented
   * @return this toolkit's implementation of the <code>Desktop</code>
   * @throws HeadlessException if GraphicsEnvironment.isHeadless() returns true
   * @see java.awt.GraphicsEnvironment#isHeadless
   * @see java.awt.Desktop
   * @see java.awt.peer.DesktopPeer
   * @since 1.6
   */
  protected abstract DesktopPeer createDesktopPeer(Desktop target)
      throws HeadlessException;


  /**
   * Creates this toolkit's implementation of <code>Button</code> using
   * the specified peer interface.
   *
   * @param target the button to be implemented.
   * @return this toolkit's implementation of <code>Button</code>.
   * @throws HeadlessException if GraphicsEnvironment.isHeadless() returns true
   * @see java.awt.GraphicsEnvironment#isHeadless
   * @see java.awt.Button
   * @see java.awt.peer.ButtonPeer
   */
  protected abstract ButtonPeer createButton(Button target)
      throws HeadlessException;

  /**
   * Creates this toolkit's implementation of <code>TextField</code> using
   * the specified peer interface.
   *
   * @param target the text field to be implemented.
   * @return this toolkit's implementation of <code>TextField</code>.
   * @throws HeadlessException if GraphicsEnvironment.isHeadless() returns true
   * @see java.awt.GraphicsEnvironment#isHeadless
   * @see java.awt.TextField
   * @see java.awt.peer.TextFieldPeer
   */
  protected abstract TextFieldPeer createTextField(TextField target)
      throws HeadlessException;

  /**
   * Creates this toolkit's implementation of <code>Label</code> using
   * the specified peer interface.
   *
   * @param target the label to be implemented.
   * @return this toolkit's implementation of <code>Label</code>.
   * @throws HeadlessException if GraphicsEnvironment.isHeadless() returns true
   * @see java.awt.GraphicsEnvironment#isHeadless
   * @see java.awt.Label
   * @see java.awt.peer.LabelPeer
   */
  protected abstract LabelPeer createLabel(Label target)
      throws HeadlessException;

  /**
   * Creates this toolkit's implementation of <code>List</code> using
   * the specified peer interface.
   *
   * @param target the list to be implemented.
   * @return this toolkit's implementation of <code>List</code>.
   * @throws HeadlessException if GraphicsEnvironment.isHeadless() returns true
   * @see java.awt.GraphicsEnvironment#isHeadless
   * @see java.awt.List
   * @see java.awt.peer.ListPeer
   */
  protected abstract ListPeer createList(java.awt.List target)
      throws HeadlessException;

  /**
   * Creates this toolkit's implementation of <code>Checkbox</code> using
   * the specified peer interface.
   *
   * @param target the check box to be implemented.
   * @return this toolkit's implementation of <code>Checkbox</code>.
   * @throws HeadlessException if GraphicsEnvironment.isHeadless() returns true
   * @see java.awt.GraphicsEnvironment#isHeadless
   * @see java.awt.Checkbox
   * @see java.awt.peer.CheckboxPeer
   */
  protected abstract CheckboxPeer createCheckbox(Checkbox target)
      throws HeadlessException;

  /**
   * Creates this toolkit's implementation of <code>Scrollbar</code> using
   * the specified peer interface.
   *
   * @param target the scroll bar to be implemented.
   * @return this toolkit's implementation of <code>Scrollbar</code>.
   * @throws HeadlessException if GraphicsEnvironment.isHeadless() returns true
   * @see java.awt.GraphicsEnvironment#isHeadless
   * @see java.awt.Scrollbar
   * @see java.awt.peer.ScrollbarPeer
   */
  protected abstract ScrollbarPeer createScrollbar(Scrollbar target)
      throws HeadlessException;

  /**
   * Creates this toolkit's implementation of <code>ScrollPane</code> using
   * the specified peer interface.
   *
   * @param target the scroll pane to be implemented.
   * @return this toolkit's implementation of <code>ScrollPane</code>.
   * @throws HeadlessException if GraphicsEnvironment.isHeadless() returns true
   * @see java.awt.GraphicsEnvironment#isHeadless
   * @see java.awt.ScrollPane
   * @see java.awt.peer.ScrollPanePeer
   * @since JDK1.1
   */
  protected abstract ScrollPanePeer createScrollPane(ScrollPane target)
      throws HeadlessException;

  /**
   * Creates this toolkit's implementation of <code>TextArea</code> using
   * the specified peer interface.
   *
   * @param target the text area to be implemented.
   * @return this toolkit's implementation of <code>TextArea</code>.
   * @throws HeadlessException if GraphicsEnvironment.isHeadless() returns true
   * @see java.awt.GraphicsEnvironment#isHeadless
   * @see java.awt.TextArea
   * @see java.awt.peer.TextAreaPeer
   */
  protected abstract TextAreaPeer createTextArea(TextArea target)
      throws HeadlessException;

  /**
   * Creates this toolkit's implementation of <code>Choice</code> using
   * the specified peer interface.
   *
   * @param target the choice to be implemented.
   * @return this toolkit's implementation of <code>Choice</code>.
   * @throws HeadlessException if GraphicsEnvironment.isHeadless() returns true
   * @see java.awt.GraphicsEnvironment#isHeadless
   * @see java.awt.Choice
   * @see java.awt.peer.ChoicePeer
   */
  protected abstract ChoicePeer createChoice(Choice target)
      throws HeadlessException;

  /**
   * Creates this toolkit's implementation of <code>Frame</code> using
   * the specified peer interface.
   *
   * @param target the frame to be implemented.
   * @return this toolkit's implementation of <code>Frame</code>.
   * @throws HeadlessException if GraphicsEnvironment.isHeadless() returns true
   * @see java.awt.GraphicsEnvironment#isHeadless
   * @see java.awt.Frame
   * @see java.awt.peer.FramePeer
   */
  protected abstract FramePeer createFrame(Frame target)
      throws HeadlessException;

  /**
   * Creates this toolkit's implementation of <code>Canvas</code> using
   * the specified peer interface.
   *
   * @param target the canvas to be implemented.
   * @return this toolkit's implementation of <code>Canvas</code>.
   * @see java.awt.Canvas
   * @see java.awt.peer.CanvasPeer
   */
  protected abstract CanvasPeer createCanvas(Canvas target);

  /**
   * Creates this toolkit's implementation of <code>Panel</code> using
   * the specified peer interface.
   *
   * @param target the panel to be implemented.
   * @return this toolkit's implementation of <code>Panel</code>.
   * @see java.awt.Panel
   * @see java.awt.peer.PanelPeer
   */
  protected abstract PanelPeer createPanel(Panel target);

  /**
   * Creates this toolkit's implementation of <code>Window</code> using
   * the specified peer interface.
   *
   * @param target the window to be implemented.
   * @return this toolkit's implementation of <code>Window</code>.
   * @throws HeadlessException if GraphicsEnvironment.isHeadless() returns true
   * @see java.awt.GraphicsEnvironment#isHeadless
   * @see java.awt.Window
   * @see java.awt.peer.WindowPeer
   */
  protected abstract WindowPeer createWindow(Window target)
      throws HeadlessException;

  /**
   * Creates this toolkit's implementation of <code>Dialog</code> using
   * the specified peer interface.
   *
   * @param target the dialog to be implemented.
   * @return this toolkit's implementation of <code>Dialog</code>.
   * @throws HeadlessException if GraphicsEnvironment.isHeadless() returns true
   * @see java.awt.GraphicsEnvironment#isHeadless
   * @see java.awt.Dialog
   * @see java.awt.peer.DialogPeer
   */
  protected abstract DialogPeer createDialog(Dialog target)
      throws HeadlessException;

  /**
   * Creates this toolkit's implementation of <code>MenuBar</code> using
   * the specified peer interface.
   *
   * @param target the menu bar to be implemented.
   * @return this toolkit's implementation of <code>MenuBar</code>.
   * @throws HeadlessException if GraphicsEnvironment.isHeadless() returns true
   * @see java.awt.GraphicsEnvironment#isHeadless
   * @see java.awt.MenuBar
   * @see java.awt.peer.MenuBarPeer
   */
  protected abstract MenuBarPeer createMenuBar(MenuBar target)
      throws HeadlessException;

  /**
   * Creates this toolkit's implementation of <code>Menu</code> using
   * the specified peer interface.
   *
   * @param target the menu to be implemented.
   * @return this toolkit's implementation of <code>Menu</code>.
   * @throws HeadlessException if GraphicsEnvironment.isHeadless() returns true
   * @see java.awt.GraphicsEnvironment#isHeadless
   * @see java.awt.Menu
   * @see java.awt.peer.MenuPeer
   */
  protected abstract MenuPeer createMenu(Menu target)
      throws HeadlessException;

  /**
   * Creates this toolkit's implementation of <code>PopupMenu</code> using
   * the specified peer interface.
   *
   * @param target the popup menu to be implemented.
   * @return this toolkit's implementation of <code>PopupMenu</code>.
   * @throws HeadlessException if GraphicsEnvironment.isHeadless() returns true
   * @see java.awt.GraphicsEnvironment#isHeadless
   * @see java.awt.PopupMenu
   * @see java.awt.peer.PopupMenuPeer
   * @since JDK1.1
   */
  protected abstract PopupMenuPeer createPopupMenu(PopupMenu target)
      throws HeadlessException;

  /**
   * Creates this toolkit's implementation of <code>MenuItem</code> using
   * the specified peer interface.
   *
   * @param target the menu item to be implemented.
   * @return this toolkit's implementation of <code>MenuItem</code>.
   * @throws HeadlessException if GraphicsEnvironment.isHeadless() returns true
   * @see java.awt.GraphicsEnvironment#isHeadless
   * @see java.awt.MenuItem
   * @see java.awt.peer.MenuItemPeer
   */
  protected abstract MenuItemPeer createMenuItem(MenuItem target)
      throws HeadlessException;

  /**
   * Creates this toolkit's implementation of <code>FileDialog</code> using
   * the specified peer interface.
   *
   * @param target the file dialog to be implemented.
   * @return this toolkit's implementation of <code>FileDialog</code>.
   * @throws HeadlessException if GraphicsEnvironment.isHeadless() returns true
   * @see java.awt.GraphicsEnvironment#isHeadless
   * @see java.awt.FileDialog
   * @see java.awt.peer.FileDialogPeer
   */
  protected abstract FileDialogPeer createFileDialog(FileDialog target)
      throws HeadlessException;

  /**
   * Creates this toolkit's implementation of <code>CheckboxMenuItem</code> using
   * the specified peer interface.
   *
   * @param target the checkbox menu item to be implemented.
   * @return this toolkit's implementation of <code>CheckboxMenuItem</code>.
   * @throws HeadlessException if GraphicsEnvironment.isHeadless() returns true
   * @see java.awt.GraphicsEnvironment#isHeadless
   * @see java.awt.CheckboxMenuItem
   * @see java.awt.peer.CheckboxMenuItemPeer
   */
  protected abstract CheckboxMenuItemPeer createCheckboxMenuItem(
      CheckboxMenuItem target) throws HeadlessException;

  /**
   * Obtains this toolkit's implementation of helper class for
   * <code>MouseInfo</code> operations.
   *
   * @return this toolkit's implementation of  helper for <code>MouseInfo</code>
   * @throws UnsupportedOperationException if this operation is not implemented
   * @see java.awt.peer.MouseInfoPeer
   * @see java.awt.MouseInfo
   * @since 1.5
   */
  protected MouseInfoPeer getMouseInfoPeer() {
    throw new UnsupportedOperationException("Not implemented");
  }

  private static LightweightPeer lightweightMarker;

  /**
   * Creates a peer for a component or container.  This peer is windowless
   * and allows the Component and Container classes to be extended directly
   * to create windowless components that are defined entirely in java.
   *
   * @param target The Component to be created.
   */
  protected LightweightPeer createComponent(Component target) {
    if (lightweightMarker == null) {
      lightweightMarker = new NullComponentPeer();
    }
    return lightweightMarker;
  }

  /**
   * Creates this toolkit's implementation of <code>Font</code> using
   * the specified peer interface.
   *
   * @param name the font to be implemented
   * @param style the style of the font, such as <code>PLAIN</code>, <code>BOLD</code>,
   * <code>ITALIC</code>, or a combination
   * @return this toolkit's implementation of <code>Font</code>
   * @see java.awt.Font
   * @see java.awt.peer.FontPeer
   * @see java.awt.GraphicsEnvironment#getAllFonts
   * @deprecated see java.awt.GraphicsEnvironment#getAllFonts
   */
  @Deprecated
  protected abstract FontPeer getFontPeer(String name, int style);

  // The following method is called by the private method
  // <code>updateSystemColors</code> in <code>SystemColor</code>.

  /**
   * Fills in the integer array that is supplied as an argument
   * with the current system color values.
   *
   * @param systemColors an integer array.
   * @throws HeadlessException if GraphicsEnvironment.isHeadless() returns true
   * @see java.awt.GraphicsEnvironment#isHeadless
   * @since JDK1.1
   */
  protected void loadSystemColors(int[] systemColors)
      throws HeadlessException {
    GraphicsEnvironment.checkHeadless();
  }

  /**
   * Controls whether the layout of Containers is validated dynamically
   * during resizing, or statically, after resizing is complete.
   * Use {@code isDynamicLayoutActive()} to detect if this feature enabled
   * in this program and is supported by this operating system
   * and/or window manager.
   * Note that this feature is supported not on all platforms, and
   * conversely, that this feature cannot be turned off on some platforms.
   * On these platforms where dynamic layout during resizing is not supported
   * (or is always supported), setting this property has no effect.
   * Note that this feature can be set or unset as a property of the
   * operating system or window manager on some platforms.  On such
   * platforms, the dynamic resize property must be set at the operating
   * system or window manager level before this method can take effect.
   * This method does not change support or settings of the underlying
   * operating system or
   * window manager.  The OS/WM support can be
   * queried using getDesktopProperty("awt.dynamicLayoutSupported") method.
   *
   * @param dynamic If true, Containers should re-layout their components as the Container is being
   * resized.  If false, the layout will be validated after resizing is completed.
   * @throws HeadlessException if GraphicsEnvironment.isHeadless() returns true
   * @see #isDynamicLayoutSet()
   * @see #isDynamicLayoutActive()
   * @see #getDesktopProperty(String propertyName)
   * @see java.awt.GraphicsEnvironment#isHeadless
   * @since 1.4
   */
  public void setDynamicLayout(final boolean dynamic)
      throws HeadlessException {
    GraphicsEnvironment.checkHeadless();
    if (this != getDefaultToolkit()) {
      getDefaultToolkit().setDynamicLayout(dynamic);
    }
  }

  /**
   * Returns whether the layout of Containers is validated dynamically
   * during resizing, or statically, after resizing is complete.
   * Note: this method returns the value that was set programmatically;
   * it does not reflect support at the level of the operating system
   * or window manager for dynamic layout on resizing, or the current
   * operating system or window manager settings.  The OS/WM support can
   * be queried using getDesktopProperty("awt.dynamicLayoutSupported").
   *
   * @return true if validation of Containers is done dynamically, false if validation is done after
   * resizing is finished.
   * @throws HeadlessException if GraphicsEnvironment.isHeadless() returns true
   * @see #setDynamicLayout(boolean dynamic)
   * @see #isDynamicLayoutActive()
   * @see #getDesktopProperty(String propertyName)
   * @see java.awt.GraphicsEnvironment#isHeadless
   * @since 1.4
   */
  protected boolean isDynamicLayoutSet()
      throws HeadlessException {
    GraphicsEnvironment.checkHeadless();

    if (this != Toolkit.getDefaultToolkit()) {
      return Toolkit.getDefaultToolkit().isDynamicLayoutSet();
    } else {
      return false;
    }
  }

  /**
   * Returns whether dynamic layout of Containers on resize is
   * currently active (both set in program
   * ( {@code isDynamicLayoutSet()} )
   * , and supported
   * by the underlying operating system and/or window manager).
   * If dynamic layout is currently inactive then Containers
   * re-layout their components when resizing is completed. As a result
   * the {@code Component.validate()} method will be invoked only
   * once per resize.
   * If dynamic layout is currently active then Containers
   * re-layout their components on every native resize event and
   * the {@code validate()} method will be invoked each time.
   * The OS/WM support can be queried using
   * the getDesktopProperty("awt.dynamicLayoutSupported") method.
   *
   * @return true if dynamic layout of Containers on resize is currently active, false otherwise.
   * @throws HeadlessException if the GraphicsEnvironment.isHeadless() method returns true
   * @see #setDynamicLayout(boolean dynamic)
   * @see #isDynamicLayoutSet()
   * @see #getDesktopProperty(String propertyName)
   * @see java.awt.GraphicsEnvironment#isHeadless
   * @since 1.4
   */
  public boolean isDynamicLayoutActive()
      throws HeadlessException {
    GraphicsEnvironment.checkHeadless();

    if (this != Toolkit.getDefaultToolkit()) {
      return Toolkit.getDefaultToolkit().isDynamicLayoutActive();
    } else {
      return false;
    }
  }

  /**
   * Gets the size of the screen.  On systems with multiple displays, the
   * primary display is used.  Multi-screen aware display dimensions are
   * available from <code>GraphicsConfiguration</code> and
   * <code>GraphicsDevice</code>.
   *
   * @return the size of this toolkit's screen, in pixels.
   * @throws HeadlessException if GraphicsEnvironment.isHeadless() returns true
   * @see java.awt.GraphicsConfiguration#getBounds
   * @see java.awt.GraphicsDevice#getDisplayMode
   * @see java.awt.GraphicsEnvironment#isHeadless
   */
  public abstract Dimension getScreenSize()
      throws HeadlessException;

  /**
   * Returns the screen resolution in dots-per-inch.
   *
   * @return this toolkit's screen resolution, in dots-per-inch.
   * @throws HeadlessException if GraphicsEnvironment.isHeadless() returns true
   * @see java.awt.GraphicsEnvironment#isHeadless
   */
  public abstract int getScreenResolution()
      throws HeadlessException;

  /**
   * Gets the insets of the screen.
   *
   * @param gc a <code>GraphicsConfiguration</code>
   * @return the insets of this toolkit's screen, in pixels.
   * @throws HeadlessException if GraphicsEnvironment.isHeadless() returns true
   * @see java.awt.GraphicsEnvironment#isHeadless
   * @since 1.4
   */
  public Insets getScreenInsets(GraphicsConfiguration gc)
      throws HeadlessException {
    GraphicsEnvironment.checkHeadless();
    if (this != Toolkit.getDefaultToolkit()) {
      return Toolkit.getDefaultToolkit().getScreenInsets(gc);
    } else {
      return new Insets(0, 0, 0, 0);
    }
  }

  /**
   * Determines the color model of this toolkit's screen.
   * <p>
   * <code>ColorModel</code> is an abstract class that
   * encapsulates the ability to translate between the
   * pixel values of an image and its red, green, blue,
   * and alpha components.
   * <p>
   * This toolkit method is called by the
   * <code>getColorModel</code> method
   * of the <code>Component</code> class.
   *
   * @return the color model of this toolkit's screen.
   * @throws HeadlessException if GraphicsEnvironment.isHeadless() returns true
   * @see java.awt.GraphicsEnvironment#isHeadless
   * @see java.awt.image.ColorModel
   * @see java.awt.Component#getColorModel
   */
  public abstract ColorModel getColorModel()
      throws HeadlessException;

  /**
   * Returns the names of the available fonts in this toolkit.<p>
   * For 1.1, the following font names are deprecated (the replacement
   * name follows):
   * <ul>
   * <li>TimesRoman (use Serif)
   * <li>Helvetica (use SansSerif)
   * <li>Courier (use Monospaced)
   * </ul><p>
   * The ZapfDingbats fontname is also deprecated in 1.1 but the characters
   * are defined in Unicode starting at 0x2700, and as of 1.1 Java supports
   * those characters.
   *
   * @return the names of the available fonts in this toolkit.
   * @see java.awt.GraphicsEnvironment#getAvailableFontFamilyNames()
   * @deprecated see {@link java.awt.GraphicsEnvironment#getAvailableFontFamilyNames()}
   */
  @Deprecated
  public abstract String[] getFontList();

  /**
   * Gets the screen device metrics for rendering of the font.
   *
   * @param font a font
   * @return the screen metrics of the specified font in this toolkit
   * @see java.awt.font.LineMetrics
   * @see java.awt.Font#getLineMetrics
   * @see java.awt.GraphicsEnvironment#getScreenDevices
   * @deprecated As of JDK version 1.2, replaced by the <code>Font</code> method
   * <code>getLineMetrics</code>.
   */
  @Deprecated
  public abstract FontMetrics getFontMetrics(Font font);

  /**
   * Synchronizes this toolkit's graphics state. Some window systems
   * may do buffering of graphics events.
   * <p>
   * This method ensures that the display is up-to-date. It is useful
   * for animation.
   */
  public abstract void sync();

  /**
   * The default toolkit.
   */
  private static Toolkit toolkit;

  /**
   * Used internally by the assistive technologies functions; set at
   * init time and used at load time
   */
  private static String atNames;

  /**
   * Initializes properties related to assistive technologies.
   * These properties are used both in the loadAssistiveProperties()
   * function below, as well as other classes in the jdk that depend
   * on the properties (such as the use of the screen_magnifier_present
   * property in Java2D hardware acceleration initialization).  The
   * initialization of the properties must be done before the platform-
   * specific Toolkit class is instantiated so that all necessary
   * properties are set up properly before any classes dependent upon them
   * are initialized.
   */
  private static void initAssistiveTechnologies() {

    // Get accessibility properties
    final String sep = File.separator;
    final Properties properties = new Properties();

    atNames = java.security.AccessController.doPrivileged(
        new java.security.PrivilegedAction<String>() {
          public String run() {

            // Try loading the per-user accessibility properties file.
            try {
              File propsFile = new File(
                  System.getProperty("user.home") +
                      sep + ".accessibility.properties");
              FileInputStream in =
                  new FileInputStream(propsFile);

              // Inputstream has been buffered in Properties class
              properties.load(in);
              in.close();
            } catch (Exception e) {
              // Per-user accessibility properties file does not exist
            }

            // Try loading the system-wide accessibility properties
            // file only if a per-user accessibility properties
            // file does not exist or is empty.
            if (properties.size() == 0) {
              try {
                File propsFile = new File(
                    System.getProperty("java.home") + sep + "lib" +
                        sep + "accessibility.properties");
                FileInputStream in =
                    new FileInputStream(propsFile);

                // Inputstream has been buffered in Properties class
                properties.load(in);
                in.close();
              } catch (Exception e) {
                // System-wide accessibility properties file does
                // not exist;
              }
            }

            // Get whether a screen magnifier is present.  First check
            // the system property and then check the properties file.
            String magPresent = System.getProperty("javax.accessibility.screen_magnifier_present");
            if (magPresent == null) {
              magPresent = properties.getProperty("screen_magnifier_present", null);
              if (magPresent != null) {
                System.setProperty("javax.accessibility.screen_magnifier_present", magPresent);
              }
            }

            // Get the names of any assistive technolgies to load.  First
            // check the system property and then check the properties
            // file.
            String classNames = System.getProperty("javax.accessibility.assistive_technologies");
            if (classNames == null) {
              classNames = properties.getProperty("assistive_technologies", null);
              if (classNames != null) {
                System.setProperty("javax.accessibility.assistive_technologies", classNames);
              }
            }
            return classNames;
          }
        });
  }

  /**
   * Loads additional classes into the VM, using the property
   * 'assistive_technologies' specified in the Sun reference
   * implementation by a line in the 'accessibility.properties'
   * file.  The form is "assistive_technologies=..." where
   * the "..." is a comma-separated list of assistive technology
   * classes to load.  Each class is loaded in the order given
   * and a single instance of each is created using
   * Class.forName(class).newInstance().  All errors are handled
   * via an AWTError exception.
   *
   * <p>The assumption is made that assistive technology classes are supplied
   * as part of INSTALLED (as opposed to: BUNDLED) extensions or specified
   * on the class path
   * (and therefore can be loaded using the class loader returned by
   * a call to <code>ClassLoader.getSystemClassLoader</code>, whose
   * delegation parent is the extension class loader for installed
   * extensions).
   */
  private static void loadAssistiveTechnologies() {
    // Load any assistive technologies
    if (atNames != null) {
      ClassLoader cl = ClassLoader.getSystemClassLoader();
      StringTokenizer parser = new StringTokenizer(atNames, " ,");
      String atName;
      while (parser.hasMoreTokens()) {
        atName = parser.nextToken();
        try {
          Class<?> clazz;
          if (cl != null) {
            clazz = cl.loadClass(atName);
          } else {
            clazz = Class.forName(atName);
          }
          clazz.newInstance();
        } catch (ClassNotFoundException e) {
          throw new AWTError("Assistive Technology not found: "
              + atName);
        } catch (InstantiationException e) {
          throw new AWTError("Could not instantiate Assistive"
              + " Technology: " + atName);
        } catch (IllegalAccessException e) {
          throw new AWTError("Could not access Assistive"
              + " Technology: " + atName);
        } catch (Exception e) {
          throw new AWTError("Error trying to install Assistive"
              + " Technology: " + atName + " " + e);
        }
      }
    }
  }

  /**
   * Gets the default toolkit.
   * <p>
   * If a system property named <code>"java.awt.headless"</code> is set
   * to <code>true</code> then the headless implementation
   * of <code>Toolkit</code> is used.
   * <p>
   * If there is no <code>"java.awt.headless"</code> or it is set to
   * <code>false</code> and there is a system property named
   * <code>"awt.toolkit"</code>,
   * that property is treated as the name of a class that is a subclass
   * of <code>Toolkit</code>;
   * otherwise the default platform-specific implementation of
   * <code>Toolkit</code> is used.
   * <p>
   * Also loads additional classes into the VM, using the property
   * 'assistive_technologies' specified in the Sun reference
   * implementation by a line in the 'accessibility.properties'
   * file.  The form is "assistive_technologies=..." where
   * the "..." is a comma-separated list of assistive technology
   * classes to load.  Each class is loaded in the order given
   * and a single instance of each is created using
   * Class.forName(class).newInstance().  This is done just after
   * the AWT toolkit is created.  All errors are handled via an
   * AWTError exception.
   *
   * @return the default toolkit.
   * @throws AWTError if a toolkit could not be found, or if one could not be accessed or
   * instantiated.
   */
  public static synchronized Toolkit getDefaultToolkit() {
    if (toolkit == null) {
      java.security.AccessController.doPrivileged(
          new java.security.PrivilegedAction<Void>() {
            public Void run() {
              Class<?> cls = null;
              String nm = System.getProperty("awt.toolkit");
              try {
                cls = Class.forName(nm);
              } catch (ClassNotFoundException e) {
                ClassLoader cl = ClassLoader.getSystemClassLoader();
                if (cl != null) {
                  try {
                    cls = cl.loadClass(nm);
                  } catch (final ClassNotFoundException ignored) {
                    throw new AWTError("Toolkit not found: " + nm);
                  }
                }
              }
              try {
                if (cls != null) {
                  toolkit = (Toolkit) cls.newInstance();
                  if (GraphicsEnvironment.isHeadless()) {
                    toolkit = new HeadlessToolkit(toolkit);
                  }
                }
              } catch (final InstantiationException ignored) {
                throw new AWTError("Could not instantiate Toolkit: " + nm);
              } catch (final IllegalAccessException ignored) {
                throw new AWTError("Could not access Toolkit: " + nm);
              }
              return null;
            }
          });
      loadAssistiveTechnologies();
    }
    return toolkit;
  }

  /**
   * Returns an image which gets pixel data from the specified file,
   * whose format can be either GIF, JPEG or PNG.
   * The underlying toolkit attempts to resolve multiple requests
   * with the same filename to the same returned Image.
   * <p>
   * Since the mechanism required to facilitate this sharing of
   * <code>Image</code> objects may continue to hold onto images
   * that are no longer in use for an indefinite period of time,
   * developers are encouraged to implement their own caching of
   * images by using the {@link #createImage(java.lang.String) createImage}
   * variant wherever available.
   * If the image data contained in the specified file changes,
   * the <code>Image</code> object returned from this method may
   * still contain stale information which was loaded from the
   * file after a prior call.
   * Previously loaded image data can be manually discarded by
   * calling the {@link Image#flush flush} method on the
   * returned <code>Image</code>.
   * <p>
   * This method first checks if there is a security manager installed.
   * If so, the method calls the security manager's
   * <code>checkRead</code> method with the file specified to ensure
   * that the access to the image is allowed.
   *
   * @param filename the name of a file containing pixel data in a recognized file format.
   * @return an image which gets its pixel data from the specified file.
   * @throws SecurityException if a security manager exists and its checkRead method doesn't allow
   * the operation.
   * @see #createImage(java.lang.String)
   */
  public abstract Image getImage(String filename);

  /**
   * Returns an image which gets pixel data from the specified URL.
   * The pixel data referenced by the specified URL must be in one
   * of the following formats: GIF, JPEG or PNG.
   * The underlying toolkit attempts to resolve multiple requests
   * with the same URL to the same returned Image.
   * <p>
   * Since the mechanism required to facilitate this sharing of
   * <code>Image</code> objects may continue to hold onto images
   * that are no longer in use for an indefinite period of time,
   * developers are encouraged to implement their own caching of
   * images by using the {@link #createImage(java.net.URL) createImage}
   * variant wherever available.
   * If the image data stored at the specified URL changes,
   * the <code>Image</code> object returned from this method may
   * still contain stale information which was fetched from the
   * URL after a prior call.
   * Previously loaded image data can be manually discarded by
   * calling the {@link Image#flush flush} method on the
   * returned <code>Image</code>.
   * <p>
   * This method first checks if there is a security manager installed.
   * If so, the method calls the security manager's
   * <code>checkPermission</code> method with the
   * url.openConnection().getPermission() permission to ensure
   * that the access to the image is allowed. For compatibility
   * with pre-1.2 security managers, if the access is denied with
   * <code>FilePermission</code> or <code>SocketPermission</code>,
   * the method throws the <code>SecurityException</code>
   * if the corresponding 1.1-style SecurityManager.checkXXX method
   * also denies permission.
   *
   * @param url the URL to use in fetching the pixel data.
   * @return an image which gets its pixel data from the specified URL.
   * @throws SecurityException if a security manager exists and its checkPermission method doesn't
   * allow the operation.
   * @see #createImage(java.net.URL)
   */
  public abstract Image getImage(URL url);

  /**
   * Returns an image which gets pixel data from the specified file.
   * The returned Image is a new object which will not be shared
   * with any other caller of this method or its getImage variant.
   * <p>
   * This method first checks if there is a security manager installed.
   * If so, the method calls the security manager's
   * <code>checkRead</code> method with the specified file to ensure
   * that the image creation is allowed.
   *
   * @param filename the name of a file containing pixel data in a recognized file format.
   * @return an image which gets its pixel data from the specified file.
   * @throws SecurityException if a security manager exists and its checkRead method doesn't allow
   * the operation.
   * @see #getImage(java.lang.String)
   */
  public abstract Image createImage(String filename);

  /**
   * Returns an image which gets pixel data from the specified URL.
   * The returned Image is a new object which will not be shared
   * with any other caller of this method or its getImage variant.
   * <p>
   * This method first checks if there is a security manager installed.
   * If so, the method calls the security manager's
   * <code>checkPermission</code> method with the
   * url.openConnection().getPermission() permission to ensure
   * that the image creation is allowed. For compatibility
   * with pre-1.2 security managers, if the access is denied with
   * <code>FilePermission</code> or <code>SocketPermission</code>,
   * the method throws <code>SecurityException</code>
   * if the corresponding 1.1-style SecurityManager.checkXXX method
   * also denies permission.
   *
   * @param url the URL to use in fetching the pixel data.
   * @return an image which gets its pixel data from the specified URL.
   * @throws SecurityException if a security manager exists and its checkPermission method doesn't
   * allow the operation.
   * @see #getImage(java.net.URL)
   */
  public abstract Image createImage(URL url);

  /**
   * Prepares an image for rendering.
   * <p>
   * If the values of the width and height arguments are both
   * <code>-1</code>, this method prepares the image for rendering
   * on the default screen; otherwise, this method prepares an image
   * for rendering on the default screen at the specified width and height.
   * <p>
   * The image data is downloaded asynchronously in another thread,
   * and an appropriately scaled screen representation of the image is
   * generated.
   * <p>
   * This method is called by components <code>prepareImage</code>
   * methods.
   * <p>
   * Information on the flags returned by this method can be found
   * with the definition of the <code>ImageObserver</code> interface.
   *
   * @param image the image for which to prepare a screen representation.
   * @param width the width of the desired screen representation, or <code>-1</code>.
   * @param height the height of the desired screen representation, or <code>-1</code>.
   * @param observer the <code>ImageObserver</code> object to be notified as the image is being
   * prepared.
   * @return <code>true</code> if the image has already been fully prepared; <code>false</code>
   * otherwise.
   * @see java.awt.Component#prepareImage(java.awt.Image, java.awt.image.ImageObserver)
   * @see java.awt.Component#prepareImage(java.awt.Image, int, int, java.awt.image.ImageObserver)
   * @see java.awt.image.ImageObserver
   */
  public abstract boolean prepareImage(Image image, int width, int height,
      ImageObserver observer);

  /**
   * Indicates the construction status of a specified image that is
   * being prepared for display.
   * <p>
   * If the values of the width and height arguments are both
   * <code>-1</code>, this method returns the construction status of
   * a screen representation of the specified image in this toolkit.
   * Otherwise, this method returns the construction status of a
   * scaled representation of the image at the specified width
   * and height.
   * <p>
   * This method does not cause the image to begin loading.
   * An application must call <code>prepareImage</code> to force
   * the loading of an image.
   * <p>
   * This method is called by the component's <code>checkImage</code>
   * methods.
   * <p>
   * Information on the flags returned by this method can be found
   * with the definition of the <code>ImageObserver</code> interface.
   *
   * @param image the image whose status is being checked.
   * @param width the width of the scaled version whose status is being checked, or
   * <code>-1</code>.
   * @param height the height of the scaled version whose status is being checked, or
   * <code>-1</code>.
   * @param observer the <code>ImageObserver</code> object to be notified as the image is being
   * prepared.
   * @return the bitwise inclusive <strong>OR</strong> of the <code>ImageObserver</code> flags for
   * the image data that is currently available.
   * @see java.awt.Toolkit#prepareImage(java.awt.Image, int, int, java.awt.image.ImageObserver)
   * @see java.awt.Component#checkImage(java.awt.Image, java.awt.image.ImageObserver)
   * @see java.awt.Component#checkImage(java.awt.Image, int, int, java.awt.image.ImageObserver)
   * @see java.awt.image.ImageObserver
   */
  public abstract int checkImage(Image image, int width, int height,
      ImageObserver observer);

  /**
   * Creates an image with the specified image producer.
   *
   * @param producer the image producer to be used.
   * @return an image with the specified image producer.
   * @see java.awt.Image
   * @see java.awt.image.ImageProducer
   * @see java.awt.Component#createImage(java.awt.image.ImageProducer)
   */
  public abstract Image createImage(ImageProducer producer);

  /**
   * Creates an image which decodes the image stored in the specified
   * byte array.
   * <p>
   * The data must be in some image format, such as GIF or JPEG,
   * that is supported by this toolkit.
   *
   * @param imagedata an array of bytes, representing image data in a supported image format.
   * @return an image.
   * @since JDK1.1
   */
  public Image createImage(byte[] imagedata) {
    return createImage(imagedata, 0, imagedata.length);
  }

  /**
   * Creates an image which decodes the image stored in the specified
   * byte array, and at the specified offset and length.
   * The data must be in some image format, such as GIF or JPEG,
   * that is supported by this toolkit.
   *
   * @param imagedata an array of bytes, representing image data in a supported image format.
   * @param imageoffset the offset of the beginning of the data in the array.
   * @param imagelength the length of the data in the array.
   * @return an image.
   * @since JDK1.1
   */
  public abstract Image createImage(byte[] imagedata,
      int imageoffset,
      int imagelength);

  /**
   * Gets a <code>PrintJob</code> object which is the result of initiating
   * a print operation on the toolkit's platform.
   * <p>
   * Each actual implementation of this method should first check if there
   * is a security manager installed. If there is, the method should call
   * the security manager's <code>checkPrintJobAccess</code> method to
   * ensure initiation of a print operation is allowed. If the default
   * implementation of <code>checkPrintJobAccess</code> is used (that is,
   * that method is not overriden), then this results in a call to the
   * security manager's <code>checkPermission</code> method with a <code>
   * RuntimePermission("queuePrintJob")</code> permission.
   *
   * @param frame the parent of the print dialog. May not be null.
   * @param jobtitle the title of the PrintJob. A null title is equivalent to "".
   * @param props a Properties object containing zero or more properties. Properties are not
   * standardized and are not consistent across implementations. Because of this, PrintJobs which
   * require job and page control should use the version of this function which takes JobAttributes
   * and PageAttributes objects. This object may be updated to reflect the user's job choices on
   * exit. May be null.
   * @return a <code>PrintJob</code> object, or <code>null</code> if the user cancelled the print
   * job.
   * @throws NullPointerException if frame is null
   * @throws SecurityException if this thread is not allowed to initiate a print job request
   * @see java.awt.GraphicsEnvironment#isHeadless
   * @see java.awt.PrintJob
   * @see java.lang.RuntimePermission
   * @since JDK1.1
   */
  public abstract PrintJob getPrintJob(Frame frame, String jobtitle,
      Properties props);

  /**
   * Gets a <code>PrintJob</code> object which is the result of initiating
   * a print operation on the toolkit's platform.
   * <p>
   * Each actual implementation of this method should first check if there
   * is a security manager installed. If there is, the method should call
   * the security manager's <code>checkPrintJobAccess</code> method to
   * ensure initiation of a print operation is allowed. If the default
   * implementation of <code>checkPrintJobAccess</code> is used (that is,
   * that method is not overriden), then this results in a call to the
   * security manager's <code>checkPermission</code> method with a <code>
   * RuntimePermission("queuePrintJob")</code> permission.
   *
   * @param frame the parent of the print dialog. May not be null.
   * @param jobtitle the title of the PrintJob. A null title is equivalent to "".
   * @param jobAttributes a set of job attributes which will control the PrintJob. The attributes
   * will be updated to reflect the user's choices as outlined in the JobAttributes documentation.
   * May be null.
   * @param pageAttributes a set of page attributes which will control the PrintJob. The attributes
   * will be applied to every page in the job. The attributes will be updated to reflect the user's
   * choices as outlined in the PageAttributes documentation. May be null.
   * @return a <code>PrintJob</code> object, or <code>null</code> if the user cancelled the print
   * job.
   * @throws NullPointerException if frame is null
   * @throws IllegalArgumentException if pageAttributes specifies differing cross feed and feed
   * resolutions. Also if this thread has access to the file system and jobAttributes specifies
   * print to file, and the specified destination file exists but is a directory rather than a
   * regular file, does not exist but cannot be created, or cannot be opened for any other reason.
   * However in the case of print to file, if a dialog is also requested to be displayed then the
   * user will be given an opportunity to select a file and proceed with printing. The dialog will
   * ensure that the selected output file is valid before returning from this method.
   * @throws SecurityException if this thread is not allowed to initiate a print job request, or if
   * jobAttributes specifies print to file, and this thread is not allowed to access the file
   * system
   * @see java.awt.PrintJob
   * @see java.awt.GraphicsEnvironment#isHeadless
   * @see java.lang.RuntimePermission
   * @see java.awt.JobAttributes
   * @see java.awt.PageAttributes
   * @since 1.3
   */
  public PrintJob getPrintJob(Frame frame, String jobtitle,
      JobAttributes jobAttributes,
      PageAttributes pageAttributes) {
    // Override to add printing support with new job/page control classes

    if (this != Toolkit.getDefaultToolkit()) {
      return Toolkit.getDefaultToolkit().getPrintJob(frame, jobtitle,
          jobAttributes,
          pageAttributes);
    } else {
      return getPrintJob(frame, jobtitle, null);
    }
  }

  /**
   * Emits an audio beep depending on native system settings and hardware
   * capabilities.
   *
   * @since JDK1.1
   */
  public abstract void beep();

  /**
   * Gets the singleton instance of the system Clipboard which interfaces
   * with clipboard facilities provided by the native platform. This
   * clipboard enables data transfer between Java programs and native
   * applications which use native clipboard facilities.
   * <p>
   * In addition to any and all formats specified in the flavormap.properties
   * file, or other file specified by the <code>AWT.DnD.flavorMapFileURL
   * </code> Toolkit property, text returned by the system Clipboard's <code>
   * getTransferData()</code> method is available in the following flavors:
   * <ul>
   * <li>DataFlavor.stringFlavor</li>
   * <li>DataFlavor.plainTextFlavor (<b>deprecated</b>)</li>
   * </ul>
   * As with <code>java.awt.datatransfer.StringSelection</code>, if the
   * requested flavor is <code>DataFlavor.plainTextFlavor</code>, or an
   * equivalent flavor, a Reader is returned. <b>Note:</b> The behavior of
   * the system Clipboard's <code>getTransferData()</code> method for <code>
   * DataFlavor.plainTextFlavor</code>, and equivalent DataFlavors, is
   * inconsistent with the definition of <code>DataFlavor.plainTextFlavor
   * </code>. Because of this, support for <code>
   * DataFlavor.plainTextFlavor</code>, and equivalent flavors, is
   * <b>deprecated</b>.
   * <p>
   * Each actual implementation of this method should first check if there
   * is a security manager installed. If there is, the method should call
   * the security manager's {@link SecurityManager#checkPermission
   * checkPermission} method to check {@code AWTPermission("accessClipboard")}.
   *
   * @return the system Clipboard
   * @throws HeadlessException if GraphicsEnvironment.isHeadless() returns true
   * @see java.awt.GraphicsEnvironment#isHeadless
   * @see java.awt.datatransfer.Clipboard
   * @see java.awt.datatransfer.StringSelection
   * @see java.awt.datatransfer.DataFlavor#stringFlavor
   * @see java.awt.datatransfer.DataFlavor#plainTextFlavor
   * @see java.io.Reader
   * @see java.awt.AWTPermission
   * @since JDK1.1
   */
  public abstract Clipboard getSystemClipboard()
      throws HeadlessException;

  /**
   * Gets the singleton instance of the system selection as a
   * <code>Clipboard</code> object. This allows an application to read and
   * modify the current, system-wide selection.
   * <p>
   * An application is responsible for updating the system selection whenever
   * the user selects text, using either the mouse or the keyboard.
   * Typically, this is implemented by installing a
   * <code>FocusListener</code> on all <code>Component</code>s which support
   * text selection, and, between <code>FOCUS_GAINED</code> and
   * <code>FOCUS_LOST</code> events delivered to that <code>Component</code>,
   * updating the system selection <code>Clipboard</code> when the selection
   * changes inside the <code>Component</code>. Properly updating the system
   * selection ensures that a Java application will interact correctly with
   * native applications and other Java applications running simultaneously
   * on the system. Note that <code>java.awt.TextComponent</code> and
   * <code>javax.swing.text.JTextComponent</code> already adhere to this
   * policy. When using these classes, and their subclasses, developers need
   * not write any additional code.
   * <p>
   * Some platforms do not support a system selection <code>Clipboard</code>.
   * On those platforms, this method will return <code>null</code>. In such a
   * case, an application is absolved from its responsibility to update the
   * system selection <code>Clipboard</code> as described above.
   * <p>
   * Each actual implementation of this method should first check if there
   * is a security manager installed. If there is, the method should call
   * the security manager's {@link SecurityManager#checkPermission
   * checkPermission} method to check {@code AWTPermission("accessClipboard")}.
   *
   * @return the system selection as a <code>Clipboard</code>, or <code>null</code> if the native
   * platform does not support a system selection <code>Clipboard</code>
   * @throws HeadlessException if GraphicsEnvironment.isHeadless() returns true
   * @see java.awt.datatransfer.Clipboard
   * @see java.awt.event.FocusListener
   * @see java.awt.event.FocusEvent#FOCUS_GAINED
   * @see java.awt.event.FocusEvent#FOCUS_LOST
   * @see TextComponent
   * @see javax.swing.text.JTextComponent
   * @see AWTPermission
   * @see GraphicsEnvironment#isHeadless
   * @since 1.4
   */
  public Clipboard getSystemSelection() throws HeadlessException {
    GraphicsEnvironment.checkHeadless();

    if (this != Toolkit.getDefaultToolkit()) {
      return Toolkit.getDefaultToolkit().getSystemSelection();
    } else {
      GraphicsEnvironment.checkHeadless();
      return null;
    }
  }

  /**
   * Determines which modifier key is the appropriate accelerator
   * key for menu shortcuts.
   * <p>
   * Menu shortcuts, which are embodied in the
   * <code>MenuShortcut</code> class, are handled by the
   * <code>MenuBar</code> class.
   * <p>
   * By default, this method returns <code>Event.CTRL_MASK</code>.
   * Toolkit implementations should override this method if the
   * <b>Control</b> key isn't the correct key for accelerators.
   *
   * @return the modifier mask on the <code>Event</code> class that is used for menu shortcuts on
   * this toolkit.
   * @throws HeadlessException if GraphicsEnvironment.isHeadless() returns true
   * @see java.awt.GraphicsEnvironment#isHeadless
   * @see java.awt.MenuBar
   * @see java.awt.MenuShortcut
   * @since JDK1.1
   */
  public int getMenuShortcutKeyMask() throws HeadlessException {
    GraphicsEnvironment.checkHeadless();

    return Event.CTRL_MASK;
  }

  /**
   * Returns whether the given locking key on the keyboard is currently in
   * its "on" state.
   * Valid key codes are
   * {@link java.awt.event.KeyEvent#VK_CAPS_LOCK VK_CAPS_LOCK},
   * {@link java.awt.event.KeyEvent#VK_NUM_LOCK VK_NUM_LOCK},
   * {@link java.awt.event.KeyEvent#VK_SCROLL_LOCK VK_SCROLL_LOCK}, and
   * {@link java.awt.event.KeyEvent#VK_KANA_LOCK VK_KANA_LOCK}.
   *
   * @throws java.lang.IllegalArgumentException if <code>keyCode</code> is not one of the valid key
   * codes
   * @throws java.lang.UnsupportedOperationException if the host system doesn't allow getting the
   * state of this key programmatically, or if the keyboard doesn't have this key
   * @throws HeadlessException if GraphicsEnvironment.isHeadless() returns true
   * @see java.awt.GraphicsEnvironment#isHeadless
   * @since 1.3
   */
  public boolean getLockingKeyState(int keyCode)
      throws UnsupportedOperationException {
    GraphicsEnvironment.checkHeadless();

    if (!(keyCode == KeyEvent.VK_CAPS_LOCK || keyCode == KeyEvent.VK_NUM_LOCK ||
        keyCode == KeyEvent.VK_SCROLL_LOCK || keyCode == KeyEvent.VK_KANA_LOCK)) {
      throw new IllegalArgumentException("invalid key for Toolkit.getLockingKeyState");
    }
    throw new UnsupportedOperationException("Toolkit.getLockingKeyState");
  }

  /**
   * Sets the state of the given locking key on the keyboard.
   * Valid key codes are
   * {@link java.awt.event.KeyEvent#VK_CAPS_LOCK VK_CAPS_LOCK},
   * {@link java.awt.event.KeyEvent#VK_NUM_LOCK VK_NUM_LOCK},
   * {@link java.awt.event.KeyEvent#VK_SCROLL_LOCK VK_SCROLL_LOCK}, and
   * {@link java.awt.event.KeyEvent#VK_KANA_LOCK VK_KANA_LOCK}.
   * <p>
   * Depending on the platform, setting the state of a locking key may
   * involve event processing and therefore may not be immediately
   * observable through getLockingKeyState.
   *
   * @throws java.lang.IllegalArgumentException if <code>keyCode</code> is not one of the valid key
   * codes
   * @throws java.lang.UnsupportedOperationException if the host system doesn't allow setting the
   * state of this key programmatically, or if the keyboard doesn't have this key
   * @throws HeadlessException if GraphicsEnvironment.isHeadless() returns true
   * @see java.awt.GraphicsEnvironment#isHeadless
   * @since 1.3
   */
  public void setLockingKeyState(int keyCode, boolean on)
      throws UnsupportedOperationException {
    GraphicsEnvironment.checkHeadless();

    if (!(keyCode == KeyEvent.VK_CAPS_LOCK || keyCode == KeyEvent.VK_NUM_LOCK ||
        keyCode == KeyEvent.VK_SCROLL_LOCK || keyCode == KeyEvent.VK_KANA_LOCK)) {
      throw new IllegalArgumentException("invalid key for Toolkit.setLockingKeyState");
    }
    throw new UnsupportedOperationException("Toolkit.setLockingKeyState");
  }

  /**
   * Give native peers the ability to query the native container
   * given a native component (eg the direct parent may be lightweight).
   */
  protected static Container getNativeContainer(Component c) {
    return c.getNativeContainer();
  }

  /**
   * Creates a new custom cursor object.
   * If the image to display is invalid, the cursor will be hidden (made
   * completely transparent), and the hotspot will be set to (0, 0).
   *
   * <p>Note that multi-frame images are invalid and may cause this
   * method to hang.
   *
   * @param cursor the image to display when the cursor is activated
   * @param hotSpot the X and Y of the large cursor's hot spot; the hotSpot values must be less than
   * the Dimension returned by <code>getBestCursorSize</code>
   * @param name a localized description of the cursor, for Java Accessibility use
   * @throws IndexOutOfBoundsException if the hotSpot values are outside the bounds of the cursor
   * @throws HeadlessException if GraphicsEnvironment.isHeadless() returns true
   * @see java.awt.GraphicsEnvironment#isHeadless
   * @since 1.2
   */
  public Cursor createCustomCursor(Image cursor, Point hotSpot, String name)
      throws IndexOutOfBoundsException, HeadlessException {
    // Override to implement custom cursor support.
    if (this != Toolkit.getDefaultToolkit()) {
      return Toolkit.getDefaultToolkit().
          createCustomCursor(cursor, hotSpot, name);
    } else {
      return new Cursor(Cursor.DEFAULT_CURSOR);
    }
  }

  /**
   * Returns the supported cursor dimension which is closest to the desired
   * sizes.  Systems which only support a single cursor size will return that
   * size regardless of the desired sizes.  Systems which don't support custom
   * cursors will return a dimension of 0, 0. <p>
   * Note:  if an image is used whose dimensions don't match a supported size
   * (as returned by this method), the Toolkit implementation will attempt to
   * resize the image to a supported size.
   * Since converting low-resolution images is difficult,
   * no guarantees are made as to the quality of a cursor image which isn't a
   * supported size.  It is therefore recommended that this method
   * be called and an appropriate image used so no image conversion is made.
   *
   * @param preferredWidth the preferred cursor width the component would like to use.
   * @param preferredHeight the preferred cursor height the component would like to use.
   * @return the closest matching supported cursor size, or a dimension of 0,0 if the Toolkit
   * implementation doesn't support custom cursors.
   * @throws HeadlessException if GraphicsEnvironment.isHeadless() returns true
   * @see java.awt.GraphicsEnvironment#isHeadless
   * @since 1.2
   */
  public Dimension getBestCursorSize(int preferredWidth,
      int preferredHeight) throws HeadlessException {
    GraphicsEnvironment.checkHeadless();

    // Override to implement custom cursor support.
    if (this != Toolkit.getDefaultToolkit()) {
      return Toolkit.getDefaultToolkit().
          getBestCursorSize(preferredWidth, preferredHeight);
    } else {
      return new Dimension(0, 0);
    }
  }

  /**
   * Returns the maximum number of colors the Toolkit supports in a custom cursor
   * palette.<p>
   * Note: if an image is used which has more colors in its palette than
   * the supported maximum, the Toolkit implementation will attempt to flatten the
   * palette to the maximum.  Since converting low-resolution images is difficult,
   * no guarantees are made as to the quality of a cursor image which has more
   * colors than the system supports.  It is therefore recommended that this method
   * be called and an appropriate image used so no image conversion is made.
   *
   * @return the maximum number of colors, or zero if custom cursors are not supported by this
   * Toolkit implementation.
   * @throws HeadlessException if GraphicsEnvironment.isHeadless() returns true
   * @see java.awt.GraphicsEnvironment#isHeadless
   * @since 1.2
   */
  public int getMaximumCursorColors() throws HeadlessException {
    GraphicsEnvironment.checkHeadless();

    // Override to implement custom cursor support.
    if (this != Toolkit.getDefaultToolkit()) {
      return Toolkit.getDefaultToolkit().getMaximumCursorColors();
    } else {
      return 0;
    }
  }

  /**
   * Returns whether Toolkit supports this state for
   * <code>Frame</code>s.  This method tells whether the <em>UI
   * concept</em> of, say, maximization or iconification is
   * supported.  It will always return false for "compound" states
   * like <code>Frame.ICONIFIED|Frame.MAXIMIZED_VERT</code>.
   * In other words, the rule of thumb is that only queries with a
   * single frame state constant as an argument are meaningful.
   * <p>Note that supporting a given concept is a platform-
   * dependent feature. Due to native limitations the Toolkit
   * object may report a particular state as supported, however at
   * the same time the Toolkit object will be unable to apply the
   * state to a given frame.  This circumstance has two following
   * consequences:
   * <ul>
   * <li>Only the return value of {@code false} for the present
   * method actually indicates that the given state is not
   * supported. If the method returns {@code true} the given state
   * may still be unsupported and/or unavailable for a particular
   * frame.
   * <li>The developer should consider examining the value of the
   * {@link java.awt.event.WindowEvent#getNewState} method of the
   * {@code WindowEvent} received through the {@link
   * java.awt.event.WindowStateListener}, rather than assuming
   * that the state given to the {@code setExtendedState()} method
   * will be definitely applied. For more information see the
   * documentation for the {@link Frame#setExtendedState} method.
   * </ul>
   *
   * @param state one of named frame state constants.
   * @return <code>true</code> is this frame state is supported by this Toolkit implementation,
   * <code>false</code> otherwise.
   * @throws HeadlessException if <code>GraphicsEnvironment.isHeadless()</code> returns
   * <code>true</code>.
   * @see java.awt.Window#addWindowStateListener
   * @since 1.4
   */
  public boolean isFrameStateSupported(int state)
      throws HeadlessException {
    GraphicsEnvironment.checkHeadless();

    if (this != Toolkit.getDefaultToolkit()) {
      return Toolkit.getDefaultToolkit().
          isFrameStateSupported(state);
    } else {
      return (state == Frame.NORMAL); // others are not guaranteed
    }
  }

  /**
   * Support for I18N: any visible strings should be stored in
   * sun.awt.resources.awt.properties.  The ResourceBundle is stored
   * here, so that only one copy is maintained.
   */
  private static ResourceBundle resources;
  private static ResourceBundle platformResources;

  // called by platform toolkit
  private static void setPlatformResources(ResourceBundle bundle) {
    platformResources = bundle;
  }

  /**
   * Initialize JNI field and method ids
   */
  private static native void initIDs();

  /**
   * WARNING: This is a temporary workaround for a problem in the
   * way the AWT loads native libraries. A number of classes in the
   * AWT package have a native method, initIDs(), which initializes
   * the JNI field and method ids used in the native portion of
   * their implementation.
   *
   * Since the use and storage of these ids is done by the
   * implementation libraries, the implementation of these method is
   * provided by the particular AWT implementations (for example,
   * "Toolkit"s/Peer), such as Motif, Microsoft Windows, or Tiny. The
   * problem is that this means that the native libraries must be
   * loaded by the java.* classes, which do not necessarily know the
   * names of the libraries to load. A better way of doing this
   * would be to provide a separate library which defines java.awt.*
   * initIDs, and exports the relevant symbols out to the
   * implementation libraries.
   *
   * For now, we know it's done by the implementation, and we assume
   * that the name of the library is "awt".  -br.
   *
   * If you change loadLibraries(), please add the change to
   * java.awt.image.ColorModel.loadLibraries(). Unfortunately,
   * classes can be loaded in java.awt.image that depend on
   * libawt and there is no way to call Toolkit.loadLibraries()
   * directly.  -hung
   */
  private static boolean loaded = false;

  static void loadLibraries() {
    if (!loaded) {
      java.security.AccessController.doPrivileged(
          new java.security.PrivilegedAction<Void>() {
            public Void run() {
              System.loadLibrary("awt");
              return null;
            }
          });
      loaded = true;
    }
  }

  static {
    AWTAccessor.setToolkitAccessor(
        new AWTAccessor.ToolkitAccessor() {
          @Override
          public void setPlatformResources(ResourceBundle bundle) {
            Toolkit.setPlatformResources(bundle);
          }
        });

    java.security.AccessController.doPrivileged(
        new java.security.PrivilegedAction<Void>() {
          public Void run() {
            try {
              resources =
                  ResourceBundle.getBundle("sun.awt.resources.awt",
                      CoreResourceBundleControl.getRBControlInstance());
            } catch (MissingResourceException e) {
              // No resource file; defaults will be used.
            }
            return null;
          }
        });

    // ensure that the proper libraries are loaded
    loadLibraries();
    initAssistiveTechnologies();
    if (!GraphicsEnvironment.isHeadless()) {
      initIDs();
    }
  }

  /**
   * Gets a property with the specified key and default.
   * This method returns defaultValue if the property is not found.
   */
  public static String getProperty(String key, String defaultValue) {
    // first try platform specific bundle
    if (platformResources != null) {
      try {
        return platformResources.getString(key);
      } catch (MissingResourceException e) {
      }
    }

    // then shared one
    if (resources != null) {
      try {
        return resources.getString(key);
      } catch (MissingResourceException e) {
      }
    }

    return defaultValue;
  }

  /**
   * Get the application's or applet's EventQueue instance.
   * Depending on the Toolkit implementation, different EventQueues
   * may be returned for different applets.  Applets should
   * therefore not assume that the EventQueue instance returned
   * by this method will be shared by other applets or the system.
   *
   * <p> If there is a security manager then its
   * {@link SecurityManager#checkPermission checkPermission} method
   * is called to check {@code AWTPermission("accessEventQueue")}.
   *
   * @return the <code>EventQueue</code> object
   * @throws SecurityException if a security manager is set and it denies access to the {@code
   * EventQueue}
   * @see java.awt.AWTPermission
   */
  public final EventQueue getSystemEventQueue() {
    SecurityManager security = System.getSecurityManager();
    if (security != null) {
      security.checkPermission(SecurityConstants.AWT.CHECK_AWT_EVENTQUEUE_PERMISSION);
    }
    return getSystemEventQueueImpl();
  }

  /**
   * Gets the application's or applet's <code>EventQueue</code>
   * instance, without checking access.  For security reasons,
   * this can only be called from a <code>Toolkit</code> subclass.
   *
   * @return the <code>EventQueue</code> object
   */
  protected abstract EventQueue getSystemEventQueueImpl();

  /* Accessor method for use by AWT package routines. */
  static EventQueue getEventQueue() {
    return getDefaultToolkit().getSystemEventQueueImpl();
  }

  /**
   * Creates the peer for a DragSourceContext.
   * Always throws InvalidDndOperationException if
   * GraphicsEnvironment.isHeadless() returns true.
   *
   * @see java.awt.GraphicsEnvironment#isHeadless
   */
  public abstract DragSourceContextPeer createDragSourceContextPeer(DragGestureEvent dge)
      throws InvalidDnDOperationException;

  /**
   * Creates a concrete, platform dependent, subclass of the abstract
   * DragGestureRecognizer class requested, and associates it with the
   * DragSource, Component and DragGestureListener specified.
   *
   * subclasses should override this to provide their own implementation
   *
   * @param abstractRecognizerClass The abstract class of the required recognizer
   * @param ds The DragSource
   * @param c The Component target for the DragGestureRecognizer
   * @param srcActions The actions permitted for the gesture
   * @param dgl The DragGestureListener
   * @return the new object or null.  Always returns null if GraphicsEnvironment.isHeadless()
   * returns true.
   * @see java.awt.GraphicsEnvironment#isHeadless
   */
  public <T extends DragGestureRecognizer> T
  createDragGestureRecognizer(Class<T> abstractRecognizerClass,
      DragSource ds, Component c, int srcActions,
      DragGestureListener dgl) {
    return null;
  }

  /**
   * Obtains a value for the specified desktop property.
   *
   * A desktop property is a uniquely named value for a resource that
   * is Toolkit global in nature. Usually it also is an abstract
   * representation for an underlying platform dependent desktop setting.
   * For more information on desktop properties supported by the AWT see
   * <a href="doc-files/DesktopProperties.html">AWT Desktop Properties</a>.
   */
  public final synchronized Object getDesktopProperty(String propertyName) {
    // This is a workaround for headless toolkits.  It would be
    // better to override this method but it is declared final.
    // "this instanceof" syntax defeats polymorphism.
    // --mm, 03/03/00
    if (this instanceof HeadlessToolkit) {
      return ((HeadlessToolkit) this).getUnderlyingToolkit()
          .getDesktopProperty(propertyName);
    }

    if (desktopProperties.isEmpty()) {
      initializeDesktopProperties();
    }

    Object value;

    // This property should never be cached
    if (propertyName.equals("awt.dynamicLayoutSupported")) {
      return getDefaultToolkit().lazilyLoadDesktopProperty(propertyName);
    }

    value = desktopProperties.get(propertyName);

    if (value == null) {
      value = lazilyLoadDesktopProperty(propertyName);

      if (value != null) {
        setDesktopProperty(propertyName, value);
      }
    }

        /* for property "awt.font.desktophints" */
    if (value instanceof RenderingHints) {
      value = ((RenderingHints) value).clone();
    }

    return value;
  }

  /**
   * Sets the named desktop property to the specified value and fires a
   * property change event to notify any listeners that the value has changed.
   */
  protected final void setDesktopProperty(String name, Object newValue) {
    // This is a workaround for headless toolkits.  It would be
    // better to override this method but it is declared final.
    // "this instanceof" syntax defeats polymorphism.
    // --mm, 03/03/00
    if (this instanceof HeadlessToolkit) {
      ((HeadlessToolkit) this).getUnderlyingToolkit()
          .setDesktopProperty(name, newValue);
      return;
    }
    Object oldValue;

    synchronized (this) {
      oldValue = desktopProperties.get(name);
      desktopProperties.put(name, newValue);
    }

    // Don't fire change event if old and new values are null.
    // It helps to avoid recursive resending of WM_THEMECHANGED
    if (oldValue != null || newValue != null) {
      desktopPropsSupport.firePropertyChange(name, oldValue, newValue);
    }
  }

  /**
   * an opportunity to lazily evaluate desktop property values.
   */
  protected Object lazilyLoadDesktopProperty(String name) {
    return null;
  }

  /**
   * initializeDesktopProperties
   */
  protected void initializeDesktopProperties() {
  }

  /**
   * Adds the specified property change listener for the named desktop
   * property. When a {@link java.beans.PropertyChangeListenerProxy} object is added,
   * its property name is ignored, and the wrapped listener is added.
   * If {@code name} is {@code null} or {@code pcl} is {@code null},
   * no exception is thrown and no action is performed.
   *
   * @param name The name of the property to listen for
   * @param pcl The property change listener
   * @see PropertyChangeSupport#addPropertyChangeListener(String, PropertyChangeListener)
   * @since 1.2
   */
  public void addPropertyChangeListener(String name, PropertyChangeListener pcl) {
    desktopPropsSupport.addPropertyChangeListener(name, pcl);
  }

  /**
   * Removes the specified property change listener for the named
   * desktop property. When a {@link java.beans.PropertyChangeListenerProxy} object
   * is removed, its property name is ignored, and
   * the wrapped listener is removed.
   * If {@code name} is {@code null} or {@code pcl} is {@code null},
   * no exception is thrown and no action is performed.
   *
   * @param name The name of the property to remove
   * @param pcl The property change listener
   * @see PropertyChangeSupport#removePropertyChangeListener(String, PropertyChangeListener)
   * @since 1.2
   */
  public void removePropertyChangeListener(String name, PropertyChangeListener pcl) {
    desktopPropsSupport.removePropertyChangeListener(name, pcl);
  }

  /**
   * Returns an array of all the property change listeners
   * registered on this toolkit. The returned array
   * contains {@link java.beans.PropertyChangeListenerProxy} objects
   * that associate listeners with the names of desktop properties.
   *
   * @return all of this toolkit's {@link PropertyChangeListener} objects wrapped in {@code
   * java.beans.PropertyChangeListenerProxy} objects or an empty array  if no listeners are added
   * @see PropertyChangeSupport#getPropertyChangeListeners()
   * @since 1.4
   */
  public PropertyChangeListener[] getPropertyChangeListeners() {
    return desktopPropsSupport.getPropertyChangeListeners();
  }

  /**
   * Returns an array of all property change listeners
   * associated with the specified name of a desktop property.
   *
   * @param propertyName the named property
   * @return all of the {@code PropertyChangeListener} objects associated with the specified name of
   * a desktop property or an empty array if no such listeners are added
   * @see PropertyChangeSupport#getPropertyChangeListeners(String)
   * @since 1.4
   */
  public PropertyChangeListener[] getPropertyChangeListeners(String propertyName) {
    return desktopPropsSupport.getPropertyChangeListeners(propertyName);
  }

  protected final Map<String, Object> desktopProperties =
      new HashMap<String, Object>();
  protected final PropertyChangeSupport desktopPropsSupport =
      Toolkit.createPropertyChangeSupport(this);

  /**
   * Returns whether the always-on-top mode is supported by this toolkit.
   * To detect whether the always-on-top mode is supported for a
   * particular Window, use {@link Window#isAlwaysOnTopSupported}.
   *
   * @return <code>true</code>, if current toolkit supports the always-on-top mode, otherwise
   * returns <code>false</code>
   * @see Window#isAlwaysOnTopSupported
   * @see Window#setAlwaysOnTop(boolean)
   * @since 1.6
   */
  public boolean isAlwaysOnTopSupported() {
    return true;
  }

  /**
   * Returns whether the given modality type is supported by this toolkit. If
   * a dialog with unsupported modality type is created, then
   * <code>Dialog.ModalityType.MODELESS</code> is used instead.
   *
   * @param modalityType modality type to be checked for support by this toolkit
   * @return <code>true</code>, if current toolkit supports given modality type, <code>false</code>
   * otherwise
   * @see java.awt.Dialog.ModalityType
   * @see java.awt.Dialog#getModalityType
   * @see java.awt.Dialog#setModalityType
   * @since 1.6
   */
  public abstract boolean isModalityTypeSupported(Dialog.ModalityType modalityType);

  /**
   * Returns whether the given modal exclusion type is supported by this
   * toolkit. If an unsupported modal exclusion type property is set on a window,
   * then <code>Dialog.ModalExclusionType.NO_EXCLUDE</code> is used instead.
   *
   * @param modalExclusionType modal exclusion type to be checked for support by this toolkit
   * @return <code>true</code>, if current toolkit supports given modal exclusion type,
   * <code>false</code> otherwise
   * @see java.awt.Dialog.ModalExclusionType
   * @see java.awt.Window#getModalExclusionType
   * @see java.awt.Window#setModalExclusionType
   * @since 1.6
   */
  public abstract boolean isModalExclusionTypeSupported(
      Dialog.ModalExclusionType modalExclusionType);

  // 8014718: logging has been removed from SunToolkit

  private static final int LONG_BITS = 64;
  private int[] calls = new int[LONG_BITS];
  private static volatile long enabledOnToolkitMask;
  private AWTEventListener eventListener = null;
  private WeakHashMap<AWTEventListener, SelectiveAWTEventListener> listener2SelectiveListener = new WeakHashMap<>();

  /*
   * Extracts a "pure" AWTEventListener from a AWTEventListenerProxy,
   * if the listener is proxied.
   */
  static private AWTEventListener deProxyAWTEventListener(AWTEventListener l) {
    AWTEventListener localL = l;

    if (localL == null) {
      return null;
    }
    // if user passed in a AWTEventListenerProxy object, extract
    // the listener
    if (l instanceof AWTEventListenerProxy) {
      localL = ((AWTEventListenerProxy) l).getListener();
    }
    return localL;
  }

  /**
   * Adds an AWTEventListener to receive all AWTEvents dispatched
   * system-wide that conform to the given <code>eventMask</code>.
   * <p>
   * First, if there is a security manager, its <code>checkPermission</code>
   * method is called with an
   * <code>AWTPermission("listenToAllAWTEvents")</code> permission.
   * This may result in a SecurityException.
   * <p>
   * <code>eventMask</code> is a bitmask of event types to receive.
   * It is constructed by bitwise OR-ing together the event masks
   * defined in <code>AWTEvent</code>.
   * <p>
   * Note:  event listener use is not recommended for normal
   * application use, but are intended solely to support special
   * purpose facilities including support for accessibility,
   * event record/playback, and diagnostic tracing.
   *
   * If listener is null, no exception is thrown and no action is performed.
   *
   * @param listener the event listener.
   * @param eventMask the bitmask of event types to receive
   * @throws SecurityException if a security manager exists and its <code>checkPermission</code>
   * method doesn't allow the operation.
   * @see #removeAWTEventListener
   * @see #getAWTEventListeners
   * @see SecurityManager#checkPermission
   * @see java.awt.AWTEvent
   * @see java.awt.AWTPermission
   * @see java.awt.event.AWTEventListener
   * @see java.awt.event.AWTEventListenerProxy
   * @since 1.2
   */
  public void addAWTEventListener(AWTEventListener listener, long eventMask) {
    AWTEventListener localL = deProxyAWTEventListener(listener);

    if (localL == null) {
      return;
    }
    SecurityManager security = System.getSecurityManager();
    if (security != null) {
      security.checkPermission(SecurityConstants.AWT.ALL_AWT_EVENTS_PERMISSION);
    }
    synchronized (this) {
      SelectiveAWTEventListener selectiveListener =
          listener2SelectiveListener.get(localL);

      if (selectiveListener == null) {
        // Create a new selectiveListener.
        selectiveListener = new SelectiveAWTEventListener(localL,
            eventMask);
        listener2SelectiveListener.put(localL, selectiveListener);
        eventListener = ToolkitEventMulticaster.add(eventListener,
            selectiveListener);
      }
      // OR the eventMask into the selectiveListener's event mask.
      selectiveListener.orEventMasks(eventMask);

      enabledOnToolkitMask |= eventMask;

      long mask = eventMask;
      for (int i = 0; i < LONG_BITS; i++) {
        // If no bits are set, break out of loop.
        if (mask == 0) {
          break;
        }
        if ((mask & 1L) != 0) {  // Always test bit 0.
          calls[i]++;
        }
        mask >>>= 1;  // Right shift, fill with zeros on left.
      }
    }
  }

  /**
   * Removes an AWTEventListener from receiving dispatched AWTEvents.
   * <p>
   * First, if there is a security manager, its <code>checkPermission</code>
   * method is called with an
   * <code>AWTPermission("listenToAllAWTEvents")</code> permission.
   * This may result in a SecurityException.
   * <p>
   * Note:  event listener use is not recommended for normal
   * application use, but are intended solely to support special
   * purpose facilities including support for accessibility,
   * event record/playback, and diagnostic tracing.
   *
   * If listener is null, no exception is thrown and no action is performed.
   *
   * @param listener the event listener.
   * @throws SecurityException if a security manager exists and its <code>checkPermission</code>
   * method doesn't allow the operation.
   * @see #addAWTEventListener
   * @see #getAWTEventListeners
   * @see SecurityManager#checkPermission
   * @see java.awt.AWTEvent
   * @see java.awt.AWTPermission
   * @see java.awt.event.AWTEventListener
   * @see java.awt.event.AWTEventListenerProxy
   * @since 1.2
   */
  public void removeAWTEventListener(AWTEventListener listener) {
    AWTEventListener localL = deProxyAWTEventListener(listener);

    if (listener == null) {
      return;
    }
    SecurityManager security = System.getSecurityManager();
    if (security != null) {
      security.checkPermission(SecurityConstants.AWT.ALL_AWT_EVENTS_PERMISSION);
    }

    synchronized (this) {
      SelectiveAWTEventListener selectiveListener =
          listener2SelectiveListener.get(localL);

      if (selectiveListener != null) {
        listener2SelectiveListener.remove(localL);
        int[] listenerCalls = selectiveListener.getCalls();
        for (int i = 0; i < LONG_BITS; i++) {
          calls[i] -= listenerCalls[i];
          assert calls[i] >= 0 : "Negative Listeners count";

          if (calls[i] == 0) {
            enabledOnToolkitMask &= ~(1L << i);
          }
        }
      }
      eventListener = ToolkitEventMulticaster.remove(eventListener,
          (selectiveListener == null) ? localL : selectiveListener);
    }
  }

  static boolean enabledOnToolkit(long eventMask) {
    return (enabledOnToolkitMask & eventMask) != 0;
  }

  synchronized int countAWTEventListeners(long eventMask) {
    int ci = 0;
    for (; eventMask != 0; eventMask >>>= 1, ci++) {
    }
    ci--;
    return calls[ci];
  }

  /**
   * Returns an array of all the <code>AWTEventListener</code>s
   * registered on this toolkit.
   * If there is a security manager, its {@code checkPermission}
   * method is called with an
   * {@code AWTPermission("listenToAllAWTEvents")} permission.
   * This may result in a SecurityException.
   * Listeners can be returned
   * within <code>AWTEventListenerProxy</code> objects, which also contain
   * the event mask for the given listener.
   * Note that listener objects
   * added multiple times appear only once in the returned array.
   *
   * @return all of the <code>AWTEventListener</code>s or an empty array if no listeners are
   * currently registered
   * @throws SecurityException if a security manager exists and its <code>checkPermission</code>
   * method doesn't allow the operation.
   * @see #addAWTEventListener
   * @see #removeAWTEventListener
   * @see SecurityManager#checkPermission
   * @see java.awt.AWTEvent
   * @see java.awt.AWTPermission
   * @see java.awt.event.AWTEventListener
   * @see java.awt.event.AWTEventListenerProxy
   * @since 1.4
   */
  public AWTEventListener[] getAWTEventListeners() {
    SecurityManager security = System.getSecurityManager();
    if (security != null) {
      security.checkPermission(SecurityConstants.AWT.ALL_AWT_EVENTS_PERMISSION);
    }
    synchronized (this) {
      EventListener[] la = ToolkitEventMulticaster
          .getListeners(eventListener, AWTEventListener.class);

      AWTEventListener[] ret = new AWTEventListener[la.length];
      for (int i = 0; i < la.length; i++) {
        SelectiveAWTEventListener sael = (SelectiveAWTEventListener) la[i];
        AWTEventListener tempL = sael.getListener();
        //assert tempL is not an AWTEventListenerProxy - we should
        // have weeded them all out
        // don't want to wrap a proxy inside a proxy
        ret[i] = new AWTEventListenerProxy(sael.getEventMask(), tempL);
      }
      return ret;
    }
  }

  /**
   * Returns an array of all the <code>AWTEventListener</code>s
   * registered on this toolkit which listen to all of the event
   * types specified in the {@code eventMask} argument.
   * If there is a security manager, its {@code checkPermission}
   * method is called with an
   * {@code AWTPermission("listenToAllAWTEvents")} permission.
   * This may result in a SecurityException.
   * Listeners can be returned
   * within <code>AWTEventListenerProxy</code> objects, which also contain
   * the event mask for the given listener.
   * Note that listener objects
   * added multiple times appear only once in the returned array.
   *
   * @param eventMask the bitmask of event types to listen for
   * @return all of the <code>AWTEventListener</code>s registered on this toolkit for the specified
   * event types, or an empty array if no such listeners are currently registered
   * @throws SecurityException if a security manager exists and its <code>checkPermission</code>
   * method doesn't allow the operation.
   * @see #addAWTEventListener
   * @see #removeAWTEventListener
   * @see SecurityManager#checkPermission
   * @see java.awt.AWTEvent
   * @see java.awt.AWTPermission
   * @see java.awt.event.AWTEventListener
   * @see java.awt.event.AWTEventListenerProxy
   * @since 1.4
   */
  public AWTEventListener[] getAWTEventListeners(long eventMask) {
    SecurityManager security = System.getSecurityManager();
    if (security != null) {
      security.checkPermission(SecurityConstants.AWT.ALL_AWT_EVENTS_PERMISSION);
    }
    synchronized (this) {
      EventListener[] la = ToolkitEventMulticaster
          .getListeners(eventListener, AWTEventListener.class);

      java.util.List<AWTEventListenerProxy> list = new ArrayList<>(la.length);

      for (int i = 0; i < la.length; i++) {
        SelectiveAWTEventListener sael = (SelectiveAWTEventListener) la[i];
        if ((sael.getEventMask() & eventMask) == eventMask) {
          //AWTEventListener tempL = sael.getListener();
          list.add(new AWTEventListenerProxy(sael.getEventMask(),
              sael.getListener()));
        }
      }
      return list.toArray(new AWTEventListener[0]);
    }
  }

  /*
   * This method notifies any AWTEventListeners that an event
   * is about to be dispatched.
   *
   * @param theEvent the event which will be dispatched.
   */
  void notifyAWTEventListeners(AWTEvent theEvent) {
    // This is a workaround for headless toolkits.  It would be
    // better to override this method but it is declared package private.
    // "this instanceof" syntax defeats polymorphism.
    // --mm, 03/03/00
    if (this instanceof HeadlessToolkit) {
      ((HeadlessToolkit) this).getUnderlyingToolkit()
          .notifyAWTEventListeners(theEvent);
      return;
    }

    AWTEventListener eventListener = this.eventListener;
    if (eventListener != null) {
      eventListener.eventDispatched(theEvent);
    }
  }

  static private class ToolkitEventMulticaster extends AWTEventMulticaster
      implements AWTEventListener {
    // Implementation cloned from AWTEventMulticaster.

    ToolkitEventMulticaster(AWTEventListener a, AWTEventListener b) {
      super(a, b);
    }

    static AWTEventListener add(AWTEventListener a,
        AWTEventListener b) {
      if (a == null) {
        return b;
      }
      if (b == null) {
        return a;
      }
      return new ToolkitEventMulticaster(a, b);
    }

    static AWTEventListener remove(AWTEventListener l,
        AWTEventListener oldl) {
      return (AWTEventListener) removeInternal(l, oldl);
    }

    // #4178589: must overload remove(EventListener) to call our add()
    // instead of the static addInternal() so we allocate a
    // ToolkitEventMulticaster instead of an AWTEventMulticaster.
    // Note: this method is called by AWTEventListener.removeInternal(),
    // so its method signature must match AWTEventListener.remove().
    protected EventListener remove(EventListener oldl) {
      if (oldl == a) {
        return b;
      }
      if (oldl == b) {
        return a;
      }
      AWTEventListener a2 = (AWTEventListener) removeInternal(a, oldl);
      AWTEventListener b2 = (AWTEventListener) removeInternal(b, oldl);
      if (a2 == a && b2 == b) {
        return this;    // it's not here
      }
      return add(a2, b2);
    }

    public void eventDispatched(AWTEvent event) {
      ((AWTEventListener) a).eventDispatched(event);
      ((AWTEventListener) b).eventDispatched(event);
    }
  }

  private class SelectiveAWTEventListener implements AWTEventListener {

    AWTEventListener listener;
    private long eventMask;
    // This array contains the number of times to call the eventlistener
    // for each event type.
    int[] calls = new int[Toolkit.LONG_BITS];

    public AWTEventListener getListener() {
      return listener;
    }

    public long getEventMask() {
      return eventMask;
    }

    public int[] getCalls() {
      return calls;
    }

    public void orEventMasks(long mask) {
      eventMask |= mask;
      // For each event bit set in mask, increment its call count.
      for (int i = 0; i < Toolkit.LONG_BITS; i++) {
        // If no bits are set, break out of loop.
        if (mask == 0) {
          break;
        }
        if ((mask & 1L) != 0) {  // Always test bit 0.
          calls[i]++;
        }
        mask >>>= 1;  // Right shift, fill with zeros on left.
      }
    }

    SelectiveAWTEventListener(AWTEventListener l, long mask) {
      listener = l;
      eventMask = mask;
    }

    public void eventDispatched(AWTEvent event) {
      long eventBit = 0; // Used to save the bit of the event type.
      if (((eventBit = eventMask & AWTEvent.COMPONENT_EVENT_MASK) != 0 &&
          event.id >= ComponentEvent.COMPONENT_FIRST &&
          event.id <= ComponentEvent.COMPONENT_LAST)
          || ((eventBit = eventMask & AWTEvent.CONTAINER_EVENT_MASK) != 0 &&
          event.id >= ContainerEvent.CONTAINER_FIRST &&
          event.id <= ContainerEvent.CONTAINER_LAST)
          || ((eventBit = eventMask & AWTEvent.FOCUS_EVENT_MASK) != 0 &&
          event.id >= FocusEvent.FOCUS_FIRST &&
          event.id <= FocusEvent.FOCUS_LAST)
          || ((eventBit = eventMask & AWTEvent.KEY_EVENT_MASK) != 0 &&
          event.id >= KeyEvent.KEY_FIRST &&
          event.id <= KeyEvent.KEY_LAST)
          || ((eventBit = eventMask & AWTEvent.MOUSE_WHEEL_EVENT_MASK) != 0 &&
          event.id == MouseEvent.MOUSE_WHEEL)
          || ((eventBit = eventMask & AWTEvent.MOUSE_MOTION_EVENT_MASK) != 0 &&
          (event.id == MouseEvent.MOUSE_MOVED ||
              event.id == MouseEvent.MOUSE_DRAGGED))
          || ((eventBit = eventMask & AWTEvent.MOUSE_EVENT_MASK) != 0 &&
          event.id != MouseEvent.MOUSE_MOVED &&
          event.id != MouseEvent.MOUSE_DRAGGED &&
          event.id != MouseEvent.MOUSE_WHEEL &&
          event.id >= MouseEvent.MOUSE_FIRST &&
          event.id <= MouseEvent.MOUSE_LAST)
          || ((eventBit = eventMask & AWTEvent.WINDOW_EVENT_MASK) != 0 &&
          (event.id >= WindowEvent.WINDOW_FIRST &&
              event.id <= WindowEvent.WINDOW_LAST))
          || ((eventBit = eventMask & AWTEvent.ACTION_EVENT_MASK) != 0 &&
          event.id >= ActionEvent.ACTION_FIRST &&
          event.id <= ActionEvent.ACTION_LAST)
          || ((eventBit = eventMask & AWTEvent.ADJUSTMENT_EVENT_MASK) != 0 &&
          event.id >= AdjustmentEvent.ADJUSTMENT_FIRST &&
          event.id <= AdjustmentEvent.ADJUSTMENT_LAST)
          || ((eventBit = eventMask & AWTEvent.ITEM_EVENT_MASK) != 0 &&
          event.id >= ItemEvent.ITEM_FIRST &&
          event.id <= ItemEvent.ITEM_LAST)
          || ((eventBit = eventMask & AWTEvent.TEXT_EVENT_MASK) != 0 &&
          event.id >= TextEvent.TEXT_FIRST &&
          event.id <= TextEvent.TEXT_LAST)
          || ((eventBit = eventMask & AWTEvent.INPUT_METHOD_EVENT_MASK) != 0 &&
          event.id >= InputMethodEvent.INPUT_METHOD_FIRST &&
          event.id <= InputMethodEvent.INPUT_METHOD_LAST)
          || ((eventBit = eventMask & AWTEvent.PAINT_EVENT_MASK) != 0 &&
          event.id >= PaintEvent.PAINT_FIRST &&
          event.id <= PaintEvent.PAINT_LAST)
          || ((eventBit = eventMask & AWTEvent.INVOCATION_EVENT_MASK) != 0 &&
          event.id >= InvocationEvent.INVOCATION_FIRST &&
          event.id <= InvocationEvent.INVOCATION_LAST)
          || ((eventBit = eventMask & AWTEvent.HIERARCHY_EVENT_MASK) != 0 &&
          event.id == HierarchyEvent.HIERARCHY_CHANGED)
          || ((eventBit = eventMask & AWTEvent.HIERARCHY_BOUNDS_EVENT_MASK) != 0 &&
          (event.id == HierarchyEvent.ANCESTOR_MOVED ||
              event.id == HierarchyEvent.ANCESTOR_RESIZED))
          || ((eventBit = eventMask & AWTEvent.WINDOW_STATE_EVENT_MASK) != 0 &&
          event.id == WindowEvent.WINDOW_STATE_CHANGED)
          || ((eventBit = eventMask & AWTEvent.WINDOW_FOCUS_EVENT_MASK) != 0 &&
          (event.id == WindowEvent.WINDOW_GAINED_FOCUS ||
              event.id == WindowEvent.WINDOW_LOST_FOCUS))
          || ((eventBit = eventMask & sun.awt.SunToolkit.GRAB_EVENT_MASK) != 0 &&
          (event instanceof sun.awt.UngrabEvent))) {
        // Get the index of the call count for this event type.
        // Instead of using Math.log(...) we will calculate it with
        // bit shifts. That's what previous implementation looked like:
        //
        // int ci = (int) (Math.log(eventBit)/Math.log(2));
        int ci = 0;
        for (long eMask = eventBit; eMask != 0; eMask >>>= 1, ci++) {
        }
        ci--;
        // Call the listener as many times as it was added for this
        // event type.
        for (int i = 0; i < calls[ci]; i++) {
          listener.eventDispatched(event);
        }
      }
    }
  }

  /**
   * Returns a map of visual attributes for the abstract level description
   * of the given input method highlight, or null if no mapping is found.
   * The style field of the input method highlight is ignored. The map
   * returned is unmodifiable.
   *
   * @param highlight input method highlight
   * @return style attribute map, or <code>null</code>
   * @throws HeadlessException if <code>GraphicsEnvironment.isHeadless</code> returns true
   * @see java.awt.GraphicsEnvironment#isHeadless
   * @since 1.3
   */
  public abstract Map<java.awt.font.TextAttribute, ?>
  mapInputMethodHighlight(InputMethodHighlight highlight)
      throws HeadlessException;

  private static PropertyChangeSupport createPropertyChangeSupport(Toolkit toolkit) {
    if (toolkit instanceof SunToolkit || toolkit instanceof HeadlessToolkit) {
      return new DesktopPropertyChangeSupport(toolkit);
    } else {
      return new PropertyChangeSupport(toolkit);
    }
  }

  @SuppressWarnings("serial")
  private static class DesktopPropertyChangeSupport extends PropertyChangeSupport {

    private static final StringBuilder PROP_CHANGE_SUPPORT_KEY =
        new StringBuilder("desktop property change support key");
    private final Object source;

    public DesktopPropertyChangeSupport(Object sourceBean) {
      super(sourceBean);
      source = sourceBean;
    }

    @Override
    public synchronized void addPropertyChangeListener(
        String propertyName,
        PropertyChangeListener listener) {
      PropertyChangeSupport pcs = (PropertyChangeSupport)
          AppContext.getAppContext().get(PROP_CHANGE_SUPPORT_KEY);
      if (null == pcs) {
        pcs = new PropertyChangeSupport(source);
        AppContext.getAppContext().put(PROP_CHANGE_SUPPORT_KEY, pcs);
      }
      pcs.addPropertyChangeListener(propertyName, listener);
    }

    @Override
    public synchronized void removePropertyChangeListener(
        String propertyName,
        PropertyChangeListener listener) {
      PropertyChangeSupport pcs = (PropertyChangeSupport)
          AppContext.getAppContext().get(PROP_CHANGE_SUPPORT_KEY);
      if (null != pcs) {
        pcs.removePropertyChangeListener(propertyName, listener);
      }
    }

    @Override
    public synchronized PropertyChangeListener[] getPropertyChangeListeners() {
      PropertyChangeSupport pcs = (PropertyChangeSupport)
          AppContext.getAppContext().get(PROP_CHANGE_SUPPORT_KEY);
      if (null != pcs) {
        return pcs.getPropertyChangeListeners();
      } else {
        return new PropertyChangeListener[0];
      }
    }

    @Override
    public synchronized PropertyChangeListener[] getPropertyChangeListeners(String propertyName) {
      PropertyChangeSupport pcs = (PropertyChangeSupport)
          AppContext.getAppContext().get(PROP_CHANGE_SUPPORT_KEY);
      if (null != pcs) {
        return pcs.getPropertyChangeListeners(propertyName);
      } else {
        return new PropertyChangeListener[0];
      }
    }

    @Override
    public synchronized void addPropertyChangeListener(PropertyChangeListener listener) {
      PropertyChangeSupport pcs = (PropertyChangeSupport)
          AppContext.getAppContext().get(PROP_CHANGE_SUPPORT_KEY);
      if (null == pcs) {
        pcs = new PropertyChangeSupport(source);
        AppContext.getAppContext().put(PROP_CHANGE_SUPPORT_KEY, pcs);
      }
      pcs.addPropertyChangeListener(listener);
    }

    @Override
    public synchronized void removePropertyChangeListener(PropertyChangeListener listener) {
      PropertyChangeSupport pcs = (PropertyChangeSupport)
          AppContext.getAppContext().get(PROP_CHANGE_SUPPORT_KEY);
      if (null != pcs) {
        pcs.removePropertyChangeListener(listener);
      }
    }

    /*
     * we do expect that all other fireXXX() methods of java.beans.PropertyChangeSupport
     * use this method.  If this will be changed we will need to change this class.
     */
    @Override
    public void firePropertyChange(final PropertyChangeEvent evt) {
      Object oldValue = evt.getOldValue();
      Object newValue = evt.getNewValue();
      String propertyName = evt.getPropertyName();
      if (oldValue != null && newValue != null && oldValue.equals(newValue)) {
        return;
      }
      Runnable updater = new Runnable() {
        public void run() {
          PropertyChangeSupport pcs = (PropertyChangeSupport)
              AppContext.getAppContext().get(PROP_CHANGE_SUPPORT_KEY);
          if (null != pcs) {
            pcs.firePropertyChange(evt);
          }
        }
      };
      final AppContext currentAppContext = AppContext.getAppContext();
      for (AppContext appContext : AppContext.getAppContexts()) {
        if (null == appContext || appContext.isDisposed()) {
          continue;
        }
        if (currentAppContext == appContext) {
          updater.run();
        } else {
          final PeerEvent e = new PeerEvent(source, updater, PeerEvent.ULTIMATE_PRIORITY_EVENT);
          SunToolkit.postEvent(appContext, e);
        }
      }
    }
  }

  /**
   * Reports whether events from extra mouse buttons are allowed to be processed and posted into
   * {@code EventQueue}. <br> To change the returned value it is necessary to set the {@code
   * sun.awt.enableExtraMouseButtons} property before the {@code Toolkit} class initialization. This
   * setting could be done on the application startup by the following command:
   * <pre>
   * java -Dsun.awt.enableExtraMouseButtons=false Application
   * </pre>
   * Alternatively, the property could be set in the application by using the following code:
   * <pre>
   * System.setProperty("sun.awt.enableExtraMouseButtons", "true");
   * </pre>
   * before the {@code Toolkit} class initialization. If not set by the time of the {@code Toolkit}
   * class initialization, this property will be initialized with {@code true}. Changing this value
   * after the {@code Toolkit} class initialization will have no effect. <p>
   *
   * @return {@code true} if events from extra mouse buttons are allowed to be processed and posted;
   * {@code false} otherwise
   * @throws HeadlessException if GraphicsEnvironment.isHeadless() returns true
   * @see System#getProperty(String propertyName)
   * @see System#setProperty(String propertyName, String value)
   * @see java.awt.EventQueue
   * @since 1.7
   */
  public boolean areExtraMouseButtonsEnabled() throws HeadlessException {
    GraphicsEnvironment.checkHeadless();

    return Toolkit.getDefaultToolkit().areExtraMouseButtonsEnabled();
  }
}
